use rtc::{
    rtp_session::SendRtpPacket,
    sdp::{Codec, Codecs, SdpSession, SdpSessionConfig},
    OpenSslContext,
};
use rtc::sdp::{RtcpMuxPolicy, TransportType};
use sdp_types::{Direction, MediaType};
use sip_auth::{DigestAuthenticator, DigestCredentials, DigestUser};
use sip_core::{transport::udp::Udp, Endpoint};
use sip_core::transport::tcp::TcpConnector;
use sip_ua::{
    dialog::DialogLayer, invite::InviteLayer, Call, CallEvent, MediaEvent, RegistrarConfig,
    Registration, RtcMediaBackend,
};
use std::sync::Arc;
use std::time::Duration;
use tokio::{select, signal::ctrl_c, time::interval};
use std::sync::mpsc as std_mpsc;
use std::thread;
use std::net::IpAddr;

// 音频编解码器
use ezk_g711::{alaw, mulaw};
use ezk_g722::G722Decoder;

// 音频播放和录音
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
use ringbuf::{HeapRb, Producer, Consumer};

/// 获取本机192.168.43开头的IP地址
fn get_local_192_168_43_ip() -> Result<IpAddr, Box<dyn std::error::Error>> {
    // 尝试获取网络接口的IP地址
    if let Ok(interfaces) = get_if_addrs::get_if_addrs() {
        for interface in interfaces {
            // 跳过回环接口和down状态的接口
            if !interface.is_loopback() && interface.addr.ip().is_ipv4() {
                let ip = interface.addr.ip();
                
                // 检查是否是192.168.43开头的IP
                if let IpAddr::V4(ipv4) = ip {
                    if ipv4.octets()[0] == 192 && ipv4.octets()[1] == 168 && ipv4.octets()[2] == 43 {
                        log::info!("找到192.168.43网段IP: {}", ip);
                        return Ok(ip);
                    }
                }
            }
        }
    }
    
    // 如果找不到192.168.43开头的IP，尝试获取任何可用的IP
    if let Ok(conn) = std::net::TcpStream::connect("8.8.8.8:80") {
        if let Ok(addr) = conn.local_addr() {
            let ip = addr.ip();
            if !ip.is_loopback() {
                log::warn!("未找到192.168.43网段IP，使用默认IP: {}", ip);
                return Ok(ip);
            }
        }
    }
    
    // 最后使用回环地址
    log::warn!("未找到合适的IP地址，使用回环地址: 127.0.0.1");
    Ok("127.0.0.1".parse()?)
}

// 音频播放器结构体
struct AudioPlayer {
    _stream: cpal::Stream,
    producer: Producer<f32, Arc<HeapRb<f32>>>,
    input_sample_rate: u32,
    output_sample_rate: u32,
    input_channels: u32,
    output_channels: u32,
}

impl AudioPlayer {
    fn new() -> Result<Self, Box<dyn std::error::Error>> {
        let host = cpal::default_host();
        let device = host.default_output_device()
            .ok_or("没有找到默认音频输出设备")?;
        
        let config = device.default_output_config()
            .map_err(|e| format!("无法获取默认音频配置: {}", e))?;
        
        log::info!("音频设备: {}, 配置: {:?}", device.name()?, config);
        
        let output_sample_rate = config.sample_rate().0;
        let output_channels = config.channels();
        
        log::info!("输出音频配置: {}Hz, {}通道", output_sample_rate, output_channels);

        // 创建环形缓冲区用于音频数据
        let ring_buffer = HeapRb::<f32>::new((output_sample_rate as f32 * 0.5) as usize); // 2秒的缓冲区
        let (producer, mut consumer) = ring_buffer.split();

        // 填充一些静音数据
        // for _ in 0..output_sample_rate as usize {
        //     producer.push(0.0).ok();
        // }
        
        let stream = device.build_output_stream(
            &config.into(),
            move |data: &mut [f32], _: &cpal::OutputCallbackInfo| {
                let mut read_frames = 0;
                for frame in data.iter_mut() {
                    if let Some(sample) = consumer.pop() {
                        *frame = sample;
                        read_frames += 1;
                    } else {
                        *frame = 0.0; // 静音
                    }
                }
                if read_frames > 0 {
                    log::debug!("播放了 {} 帧音频", read_frames);
                }
            },
            |err| log::error!("音频播放错误: {}", err),
            None,
        )?;
        
        stream.play()?;
        
        Ok(AudioPlayer {
            _stream: stream,
            producer,
            input_sample_rate: 8000, // 默认输入采样率，会在播放时更新
            output_sample_rate,
            input_channels: 1, // 默认单声道，会在播放时更新
            output_channels: output_channels.into(),
        })
    }
    
    fn update_config(&mut self, input_sample_rate: u32, input_channels: u32) {
        if self.input_sample_rate != input_sample_rate || self.input_channels != input_channels {
            log::info!("更新音频配置: {}Hz {}通道 -> {}Hz {}通道", 
                      input_sample_rate, input_channels, 
                      self.output_sample_rate, self.output_channels);
            
            self.input_sample_rate = input_sample_rate;
            self.input_channels = input_channels;
        }
    }
    
    /// 线性重采样函数
    /// 
    /// 将输入音频从一种采样率转换为另一种采样率，使用线性插值算法。
    /// 线性插值是一种简单但有效的重采样方法，通过连接相邻采样点来估计中间值。
    /// 同时处理通道数转换，支持单声道/立体声之间的转换。
    /// 
    /// # 算法原理
    /// 
    /// 1. **采样率比例计算**: ratio = output_sample_rate / input_sample_rate
    ///    - ratio > 1: 上采样（增加采样点，如8kHz -> 48kHz）
    ///    - ratio < 1: 下采样（减少采样点，如48kHz -> 8kHz）
    ///    - ratio = 1: 无需重采样
    /// 
    /// 2. **线性插值公式**: 
    ///    output_sample = current_sample * (1 - fraction) + next_sample * fraction
    ///    其中 fraction 是当前输出位置在两个输入采样点之间的比例
    /// 
    /// 3. **通道处理**:
    ///    - 单声道转立体声：复制到所有通道，多余通道用静音填充
    ///    - 立体声转单声道：只保留第一个通道
    /// 
    /// # 参数
    /// 
    /// * `input_samples` - 输入的音频样本数据（f32格式，范围[-1.0, 1.0]）
    /// * `input_channels` - 输入音频的通道数
    /// 
    /// # 返回值
    /// 
    /// 重采样后的音频数据，采样率已转换为输出设备的采样率，通道数已匹配输出设备
    /// 
    /// # 示例
    /// 
    /// ```rust
    /// // 8kHz 单声道音频重采样到 48kHz 立体声
    /// let input = [0.1, 0.2, 0.3, 0.4]; // 4个单声道样本
    /// let output = resample_linear(&input, 1);
    /// // 输出约48个样本（4帧 * 6倍重采样 * 2通道）
    /// ```
    fn resample_linear(&self, input_samples: &[f32], input_channels: u32) -> Vec<f32> {
        // 如果输入和输出采样率相同，跳过重采样，只处理通道数转换
        if self.input_sample_rate == self.output_sample_rate {
            log::debug!("采样率相同，跳过重采样: {}Hz", self.input_sample_rate);
            return self.handle_channels(input_samples, input_channels);
        }
        
        // 计算重采样比例
        // ratio > 1 表示上采样（如8kHz -> 48kHz，ratio = 6.0）
        // ratio < 1 表示下采样（如48kHz -> 8kHz，ratio = 0.167）
        let ratio = self.output_sample_rate as f32 / self.input_sample_rate as f32;
        log::debug!("重采样比例: {} ({}Hz -> {}Hz)", ratio, self.input_sample_rate, self.output_sample_rate);
        
        // 计算输入和输出的帧数
        // 音频数据按帧组织：每帧包含所有通道的样本 每个通道包含的样本数是input_channels
        let input_frames = input_samples.len() / input_channels as usize;
        // 输出帧数 = 输入帧数 * 重采样比例（四舍五入）
        let output_frames = (input_frames as f32 * ratio).round() as usize;
        
        log::debug!("重采样: {}帧 -> {}帧 ({}通道)", input_frames, output_frames, input_channels);
        
        // 预分配输出缓冲区，避免动态扩容
        let mut output_samples = Vec::with_capacity(output_frames * self.output_channels as usize);
        
        // 逐帧进行重采样
        for frame in 0..output_frames {
            // 计算当前输出帧对应的输入帧位置
            // 例如：输出帧5对应输入帧 5/6 = 0.833，即输入帧0和1之间 向下取整
            let input_frame = (frame as f32 / ratio) as usize;
            
            // 下一个输入帧位置（用于线性插值）
            let next_input_frame = input_frame + 1;
            
            // 为每个输出通道生成重采样后的样本
            let mut last_sample = 0.0;
            for channel in 0..self.output_channels as usize {
                let sample = if channel < input_channels as usize {
                    // 当前输入帧中对应通道的样本 这里假设了输入的音频是按交替通道的顺序排列的
                    let current_sample = input_samples[input_frame * input_channels as usize + channel];
                    
                    // 检查是否有下一个输入帧用于插值
                    if next_input_frame < input_frames {
                        // 下一个输入帧中对应通道的样本
                        let next_sample = input_samples[next_input_frame * input_channels as usize + channel];
                        
                        // 计算插值比例（fraction）
                        // 例如：输出帧5对应输入位置5/6=0.833，fraction=0.833-0=0.833 取出小数部分，表示靠近程度
                        let fraction = (frame as f32 / ratio) - input_frame as f32;
                        
                        // 线性插值：current * (1-fraction) + next * fraction
                        // 当fraction=0时，完全使用current_sample
                        // 当fraction=1时，完全使用next_sample
                        // 当fraction=0.5时，两个样本的平均值
                        current_sample * (1.0 - fraction) + next_sample * fraction
                    } else {
                        // 没有下一个输入帧，直接使用当前样本
                        // 这种情况发生在重采样的最后部分
                        //也就是样本总数不是偶数的时候，这里最后一个
                        current_sample
                    }
                } else {
                    // 输出通道数多于输入通道数，用静音填充
                    // 例如：单声道输入，立体声输出时，右声道用静音
                    // 这里用上一个样本的值填充
                    last_sample
                };
                last_sample = sample;
                output_samples.push(sample);
            }
        }
        
        log::debug!("重采样完成: {}样本 -> {}样本", input_samples.len(), output_samples.len());
        output_samples
    }
    
    /// 通道数处理函数
    /// 
    /// 处理输入和输出通道数不匹配的情况，包括：
    /// - 单声道到立体声的转换
    /// - 立体声到单声道的转换
    /// - 多声道系统的通道映射
    /// 
    /// # 处理策略
    /// 
    /// 1. **通道数匹配**: 直接返回输入数据
    /// 2. **输出通道数 > 输入通道数**: 用静音填充额外通道
    /// 3. **输出通道数 < 输入通道数**: 只保留前几个通道
    /// 
    /// # 参数
    /// 
    /// * `input_samples` - 输入的音频样本数据
    /// * `input_channels` - 输入音频的通道数
    /// 
    /// # 返回值
    /// 
    /// 处理后的音频数据，通道数已匹配输出设备
    /// 
    /// # 示例
    /// 
    /// ```rust
    /// // 单声道转立体声
    /// let input = [0.1, 0.2, 0.3, 0.4]; // 4个单声道样本
    /// let output = handle_channels(&input, 1); // 1个输入通道
    /// // 输出: [0.1, 0.0, 0.2, 0.0, 0.3, 0.0, 0.4, 0.0] // 立体声，右声道静音
    /// ```
    fn handle_channels(&self, input_samples: &[f32], input_channels: u32) -> Vec<f32> {
        // 如果输入和输出通道数相同，直接返回（可能应用声道映射）
        if input_channels == self.output_channels {
            log::debug!("通道数匹配: {}通道", input_channels);
            return input_samples.to_vec();
        }
        
        // 计算音频帧数（每帧包含所有通道的样本）
        let frames = input_samples.len() / input_channels as usize;
        log::debug!("通道转换: {}通道 -> {}通道 ({}帧)", input_channels, self.output_channels, frames);
        
        // 预分配输出缓冲区
        let mut output_samples = Vec::with_capacity(frames * self.output_channels as usize);
        
        // 逐帧处理通道转换
        for frame in 0..frames {
            // 为每个输出通道生成样本
            for output_channel in 0..self.output_channels as usize {
                let sample = if output_channel < input_channels as usize {
                    // 有对应的输入通道，直接复制
                    // 例如：立体声转单声道时，只保留左声道（通道0）
                    input_samples[frame * input_channels as usize + output_channel]
                } else {
                    // 没有对应的输入通道，用静音填充
                    // 例如：单声道转立体声时，右声道用静音
                    0.0
                };
                output_samples.push(sample);
            }
        }
        
        log::debug!("通道转换完成: {}样本 -> {}样本", input_samples.len(), output_samples.len());
        output_samples
    }
    
    fn play_audio(&mut self, samples: &[i16], sample_rate: u32, channels: u32) {
        // 更新配置
        self.update_config(sample_rate, channels);
        
        // 将i16转换为f32，范围从[-32768, 32767]转换为[-1.0, 1.0]
        let input_samples: Vec<f32> = samples.iter()
            .map(|&sample| sample as f32 / 32768.0)
            .collect();
        
        // 重采样和通道处理
        let output_samples = self.resample_linear(&input_samples, channels);
        
        // 发送处理后的音频数据
        for &sample in &output_samples {
            if let Err(_) = self.producer.push(sample) {
                log::warn!("音频缓冲区已满，丢弃音频数据");
                break;
            }
        }
    }
}

// 音频录音器结构体
struct AudioRecorder {
    _stream: cpal::Stream,
    consumer: Consumer<f32, Arc<HeapRb<f32>>>,
    input_sample_rate: u32,  // 添加输入采样率字段
    target_sample_rate: u32,
    target_channels: u32,
}

impl AudioRecorder {
    fn new(target_sample_rate: u32, target_channels: u32) -> Result<Self, Box<dyn std::error::Error>> {
        let host = cpal::default_host();
        let device = host.default_input_device()
            .ok_or("没有找到默认音频输入设备")?;
        
        let config = device.default_input_config()
            .map_err(|e| format!("无法获取默认音频输入配置: {}", e))?;
        
        log::info!("麦克风设备: {}, 配置: {:?}", device.name()?, config);
        
        let input_sample_rate = config.sample_rate().0;
        let input_channels = config.channels();
        
        log::info!("麦克风配置: {}Hz, {}通道", input_sample_rate, input_channels);
        log::info!("目标配置: {}Hz, {}通道", target_sample_rate, target_channels);

        // 创建环形缓冲区用于音频数据
        let ring_buffer = HeapRb::<f32>::new((input_sample_rate as f32 * 0.5) as usize); // 2秒的缓冲区
        let (mut producer, consumer) = ring_buffer.split();
        
        let stream = device.build_input_stream(
            &config.into(),
            move |data: &[f32], _: &cpal::InputCallbackInfo| {
                for &sample in data {
                    if let Err(_) = producer.push(sample) {
                        log::warn!("麦克风缓冲区已满，丢弃音频数据");
                        break;
                    }
                }
            },
            |err| log::error!("麦克风录音错误: {}", err),
            None,
        )?;
        
        stream.play()?;
        
        Ok(AudioRecorder {
            _stream: stream,
            consumer,
            input_sample_rate,  // 保存真实的输入采样率
            target_sample_rate,
            target_channels,
        })
    }
    
    /// 从麦克风读取音频数据
    fn read_audio(&mut self) -> Vec<i16> {
        let mut samples = Vec::new();
        
        // 读取可用的音频数据
        while let Some(sample) = self.consumer.pop() {
            samples.push(sample);
        }
        
        if samples.is_empty() {
            return Vec::new();
        }
        
        // 重采样到目标采样率
        let resampled_samples = self.resample_audio(&samples);
        
        // 转换为i16格式
        let i16_samples: Vec<i16> = resampled_samples.iter()
            .map(|&sample| {
                // 将f32范围[-1.0, 1.0]转换为i16范围[-32768, 32767]
                let clamped = sample.max(-1.0).min(1.0);
                (clamped * 32767.0) as i16
            })
            .collect();
        
        i16_samples
    }
    
    /// 重采样音频数据到目标采样率
    /// 
    /// 将输入音频从麦克风的实际采样率转换为目标采样率（如8kHz用于SIP通话）。
    /// 使用线性插值算法进行重采样，这是一种简单但有效的方法。
    /// 
    /// # 算法原理
    /// 
    /// 1. **采样率比例计算**: ratio = target_sample_rate / input_sample_rate
    ///    - ratio > 1: 上采样（增加采样点，如48kHz -> 96kHz）
    ///    - ratio < 1: 下采样（减少采样点，如48kHz -> 8kHz）
    ///    - ratio = 1: 无需重采样
    /// 
    /// 2. **线性插值公式**: 
    ///    output_sample = current_sample * (1 - fraction) + next_sample * fraction
    ///    其中 fraction 是当前输出位置在两个输入采样点之间的比例
    /// 
    /// # 参数
    /// 
    /// * `input_samples` - 输入的音频样本数据（f32格式，范围[-1.0, 1.0]）
    /// 
    /// # 返回值
    /// 
    /// 重采样后的音频数据，采样率已转换为目标采样率
    /// 
    /// # 示例
    /// 
    /// ```rust
    /// // 48kHz 音频重采样到 8kHz
    /// let input = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6]; // 6个样本
    /// let output = resample_audio(&input);
    /// // 输出约1个样本（6 * 8/48 = 1倍重采样）
    /// ```
    fn resample_audio(&self, input_samples: &[f32]) -> Vec<f32> {
        // 计算重采样比例
        // 例如：48kHz -> 8kHz，ratio = 8/48 = 0.167（下采样）
        // 例如：8kHz -> 48kHz，ratio = 48/8 = 6.0（上采样）
        let ratio = self.target_sample_rate as f32 / self.input_sample_rate as f32;
        
        // 如果采样率相同，无需重采样，直接返回
        if ratio == 1.0 {
            return input_samples.to_vec();
        }
        
        // 计算输入和输出的样本数
        let input_frames = input_samples.len();
        // 输出样本数 = 输入样本数 * 重采样比例（四舍五入）
        let output_frames = (input_frames as f32 * ratio).round() as usize;
        
        // 预分配输出缓冲区，避免动态扩容
        let mut output_samples = Vec::with_capacity(output_frames);
        
        // 逐样本进行重采样
        for frame in 0..output_frames {
            // 计算当前输出样本对应的输入样本位置
            // 例如：输出样本5对应输入位置 5/0.167 = 29.94，即输入样本29和30之间
            let input_frame = (frame as f32 / ratio) as usize;
            
            // 下一个输入样本位置（用于线性插值）
            let next_input_frame = input_frame + 1;
            
            let sample = if next_input_frame < input_frames {
                // 有下一个输入样本，进行线性插值
                let current_sample = input_samples[input_frame];
                let next_sample = input_samples[next_input_frame];
                
                // 计算插值比例（fraction）
                // 例如：输出样本5对应输入位置29.94，fraction = 29.94 - 29 = 0.94
                let fraction = (frame as f32 / ratio) - input_frame as f32;
                
                // 线性插值：current * (1-fraction) + next * fraction
                // 当fraction=0时，完全使用current_sample
                // 当fraction=1时，完全使用next_sample
                // 当fraction=0.5时，两个样本的平均值
                current_sample * (1.0 - fraction) + next_sample * fraction
            } else {
                // 没有下一个输入样本，直接使用当前样本
                // 这种情况发生在重采样的最后部分，防止数组越界
                input_samples[input_frame.min(input_frames - 1)]
            };
            
            output_samples.push(sample);
        }
        
        output_samples
    }
}

// 音频编码器结构体
struct AudioEncoder {
    codec_name: String,
    sample_rate: u32,
    channels: u32,
}

impl AudioEncoder {
    fn new(codec_name: &str, sample_rate: u32, channels: u32) -> Self {
        Self {
            codec_name: codec_name.to_string(),
            sample_rate,
            channels,
        }
    }
    
    fn encode(&self, samples: &[i16]) -> Vec<u8> {
        match self.codec_name.as_str() {
            "PCMU" => {
                // μ-law编码
                samples.iter().map(|&sample| mulaw::encode(sample)).collect()
            }
            "PCMA" => {
                // A-law编码
                samples.iter().map(|&sample| alaw::encode(sample)).collect()
            }
            "G722" => {
                // G.722编码（简化实现，实际需要更复杂的编码器）
                log::warn!("G.722编码暂未实现，使用PCMU替代");
                samples.iter().map(|&sample| mulaw::encode(sample)).collect()
            }
            _ => {
                log::warn!("不支持的编解码器: {}，使用PCMU替代", self.codec_name);
                samples.iter().map(|&sample| mulaw::encode(sample)).collect()
            }
        }
    }
}

// 音频解码器结构体
struct AudioDecoder {
    g722_decoder: Option<G722Decoder>,
    codec_name: String,
}

impl AudioDecoder {
    fn new(codec_name: &str, _sample_rate: u32) -> Self {
        let g722_decoder = if codec_name == "G722" {
            Some(G722Decoder::new())
        } else {
            None
        };
        
        Self {
            g722_decoder,
            codec_name: codec_name.to_string(),
        }
    }
    
    fn decode(&mut self, encoded_data: &[u8]) -> Vec<i16> {
        match self.codec_name.as_str() {
            "PCMU" => {
                // μ-law解码
                encoded_data.iter().map(|&byte| mulaw::decode(byte)).collect()
            }
            "PCMA" => {
                // A-law解码
                encoded_data.iter().map(|&byte| alaw::decode(byte)).collect()
            }
            "G722" => {
                // G.722解码
                if let Some(ref mut decoder) = self.g722_decoder {
                    let mut decoded_samples = Vec::new();
                    decoder.decode(encoded_data, &mut decoded_samples);
                    decoded_samples
                } else {
                    Vec::new()
                }
            }
            _ => {
                log::warn!("不支持的编解码器: {}", self.codec_name);
                Vec::new()
            }
        }
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(
        env_logger::Env::default().default_filter_or("info"),
    )
    .format_timestamp_secs()
    .init();

    log::info!("示例启动: make_call_zoiper");

    let mut builder = Endpoint::builder();

    // 监听 UDP 5060（常见默认）；SIP 出站通过 TCP 工厂
    Udp::spawn(&mut builder, "0.0.0.0:5060").await.unwrap();
    builder.add_transport_factory(Arc::new(TcpConnector::new()));

    // 模拟 Zoiper 的 UA 字符串（仅示例，非必须）
    builder.user_agent("Zoiper rv2.8.87-mod");

    // SIP 层
    builder.add_layer(DialogLayer::default());
    builder.add_layer(InviteLayer::default());

    let endpoint = builder.build();
    log::info!("SIP Endpoint 构建完成");

    // 认证配置（示例）
    let mut credentials = DigestCredentials::new();
    credentials.add_for_realm("192.168.43.252", DigestUser::new("1000", "1234"));

    // 使用 TCP 进行注册（registrar URI 带 transport=TCP）
    log::info!("开始注册到注册服务器 sip:192.168.43.252 (用户 1000, TCP)");
    let registration = Registration::register(
        endpoint,
        RegistrarConfig::new("1000".into(), "sip:192.168.43.252;transport=TCP".parse()?),
        DigestAuthenticator::new(credentials.clone()),
    )
    .await?;
    log::info!("注册成功");

    // SDP 会话：模仿 Zoiper 偏好（RTP/AVP、无 AVPF，rtcp-mux 协商）
    let mut sdp_cfg = SdpSessionConfig::default();
    sdp_cfg.offer_transport = TransportType::Rtp;
    sdp_cfg.offer_avpf = false;
    sdp_cfg.rtcp_mux_policy = RtcpMuxPolicy::Negotiate;

    let local_ip = get_local_192_168_43_ip()?;
    let mut sdp_session = SdpSession::new(
        OpenSslContext::try_new()?,
        local_ip,
        sdp_cfg,
    );

    // 宣告 PCMU/PCMA 优先 + DTMF（符合 Zoiper 常见应答）
    let audio = sdp_session
        .add_local_media(
            Codecs::new(MediaType::Audio)
                .with_codec(Codec::PCMU)
                .with_codec(Codec::PCMA)
                .with_dtmf(),
            Direction::SendRecv,
        )
        .unwrap();
    sdp_session.add_media(audio, Direction::SendRecv);

    // 拨号 1003（由注册域推断出目标 URI）
    log::info!("发起呼叫: 1003");
    let mut outbound_call = registration
        .make_call(
            "1003".into(),
            DigestAuthenticator::new(credentials.clone()),
            RtcMediaBackend::new(sdp_session),
        )
        .await?;
    log::info!("INVITE 已发送，等待响应或取消 (Ctrl+C)");

    let unacknowledged_call = select! {
        result = outbound_call.wait_for_completion() => {
            log::info!("收到 2xx 响应，准备完成呼叫建立 (发送 ACK)");
            result?
        },
        _ = ctrl_c() => {
            log::info!("收到 Ctrl+C，取消呼叫");
            outbound_call.cancel().await?;
            return Ok(());
        }
    };

    let call = unacknowledged_call.finish().await?;
    log::info!("呼叫已建立");

    call_event_loop(call).await?;

    Ok(())
}

async fn call_event_loop(
    mut call: Call<RtcMediaBackend>,
) -> Result<(), Box<dyn std::error::Error>> {
    log::info!("进入呼叫事件循环");

    // 创建通道用于传递音频数据（使用std::sync::mpsc）
    let (audio_tx, audio_rx) = std_mpsc::channel::<(Vec<i16>, u32, u32)>();

    // 在单独的线程中运行音频播放器
    let audio_thread = thread::spawn(move || {
        let mut audio_player = match AudioPlayer::new() {
            Ok(player) => {
                log::info!("音频播放器初始化完成");
                player
            }
            Err(e) => {
                log::error!("音频播放器初始化失败: {}", e);
                return;
            }
        };

        // 接收音频数据并播放
        while let Ok((samples, sample_rate, channels)) = audio_rx.recv() {
            audio_player.play_audio(&samples, sample_rate, channels);
        }
        log::info!("音频播放线程结束");
    });

    loop {
        match call.run().await? {
            CallEvent::Internal(event) => call.handle_internal_event(event).await?,
            CallEvent::Media(MediaEvent::ReceiverAdded { mut receiver, codec }) => {
                log::info!("媒体接收器已添加: codec={}, pt={}", codec.name, codec.pt);
                
                // 创建音频解码器
                let mut audio_decoder = AudioDecoder::new(&codec.name, codec.clock_rate);
                log::info!("音频解码器初始化完成: {} @ {}Hz", codec.name, codec.clock_rate);
                
                // 克隆音频发送器
                let audio_tx_clone = audio_tx.clone();
                
                tokio::spawn(async move {
                    log::info!("开始接收音频数据");
                    let mut packet_count = 0;
                    
                    while let Some(rtp_packet) = receiver.recv().await {
                        packet_count += 1;
                        
                        // 提取RTP包中的音频数据
                        let encoded_audio_data = rtp_packet.payload.as_ref();
                        
                        if !encoded_audio_data.is_empty() {
                            // 解码音频数据
                            let decoded_samples = audio_decoder.decode(encoded_audio_data);
                            
                            if !decoded_samples.is_empty() {
                                // 通过通道发送解码后的音频数据
                                let channels = codec.channels.unwrap_or(1) as u32;
                                if let Err(_) = audio_tx_clone.send((decoded_samples, codec.clock_rate, channels)) {
                                    log::warn!("音频通道已满，丢弃音频数据");
                                }
                                
                                if packet_count % 50 == 0 { // 每50个包记录一次
                                    log::debug!("已处理 {} 个音频包，当前包大小: {} 字节", 
                                               packet_count, encoded_audio_data.len());
                                }
                            }
                        }
                    }
                    log::info!("音频接收任务结束，总共处理了 {} 个包", packet_count);
                });
            }
            CallEvent::Media(MediaEvent::SenderAdded { mut sender, codec }) => {
                log::info!("媒体发送器已添加: codec={}, pt={}", codec.name, codec.pt);

                let max_mtu = call
                    .media()
                    .sdp_session()
                    .max_payload_size_for_media(sender.media_id())
                    .unwrap();

                // 创建音频编码器
                let audio_encoder = AudioEncoder::new(&codec.name, codec.clock_rate, codec.channels.unwrap_or(1) as u32);
                log::info!("音频编码器初始化完成: {} @ {}Hz {}通道", codec.name, codec.clock_rate, codec.channels.unwrap_or(1));

                // 使用Arc<Mutex<VecDeque>>来共享音频数据队列
                use std::collections::VecDeque;
                use std::sync::Mutex;
                
                let audio_queue = Arc::new(Mutex::new(VecDeque::<Vec<i16>>::new()));
                let audio_queue_clone = audio_queue.clone();

                // 在单独的线程中运行麦克风录音
                let _mic_thread = thread::spawn(move || {
                    let mut audio_recorder = match AudioRecorder::new(codec.clock_rate, codec.channels.unwrap_or(1) as u32) {
                        Ok(recorder) => {
                            log::info!("音频录音器初始化完成: {} @ {}Hz {}通道", codec.name, codec.clock_rate, codec.channels.unwrap_or(1));
                            recorder
                        }
                        Err(e) => {
                            log::error!("音频录音器初始化失败: {}", e);
                            return;
                        }
                    };

                    // 麦克风录音循环
                    loop {
                        let audio_samples = audio_recorder.read_audio();
                        if !audio_samples.is_empty() {
                            if let Ok(mut queue) = audio_queue_clone.lock() {
                                queue.push_back(audio_samples);
                                // 限制队列大小，避免内存溢出
                                if queue.len() > 50 {
                                    queue.pop_front();
                                }
                            }
                        }
                        std::thread::sleep(Duration::from_millis(10)); // 10ms间隔
                    }
                });

                // 在异步任务中处理音频发送
                tokio::spawn(async move {
                    let mut tick = interval(Duration::from_millis(20)); // 50fps，每20ms发送一个RTP包
                    let mut packet_count = 0;
                    
                    loop {
                        let instant = tick.tick().await;
                        packet_count += 1;
                        
                        // 从音频队列读取音频数据
                        let audio_samples = {
                            if let Ok(mut queue) = audio_queue.lock() {
                                queue.pop_front().unwrap_or_else(|| {
                                    // 如果没有音频数据，生成静音
                                    vec![0i16; 160] // 20ms @ 8kHz = 160 samples
                                })
                            } else {
                                // 如果锁失败，生成静音
                                vec![0i16; 160]
                            }
                        };
                        
                        // 编码音频数据
                        let encoded_audio_data = audio_encoder.encode(&audio_samples);
                        
                        // 确保编码后的数据不超过MTU
                        let payload_data = if encoded_audio_data.len() > max_mtu {
                            &encoded_audio_data[..max_mtu]
                        } else {
                            &encoded_audio_data
                        };
                        
                        // 发送RTP包
                        if let Err(e) = sender
                            .send(SendRtpPacket::new(
                                instant.into(),
                                codec.pt,
                                payload_data.to_vec().into(),
                            ))
                            .await
                        {
                            log::error!("发送RTP包失败: {}", e);
                            break;
                        }
                        
                        if packet_count % 50 == 0 { // 每50个包记录一次
                            log::debug!("已发送 {} 个音频包，当前包大小: {} 字节", 
                                       packet_count, payload_data.len());
                        }
                    }
                    log::info!("音频发送任务结束，总共发送了 {} 个包", packet_count);
                });
            }
            CallEvent::Terminated => {
                log::info!("呼叫已结束");
                // 等待音频播放线程结束
                let _ = audio_thread.join();
                return Ok(());
            }
        }
    }
}


